home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / cdev / sludge.sit / Source Code / State_Storage_Manager.c < prev    next >
Text File  |  1999-10-07  |  51KB  |  901 lines

  1. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  2.   Ñ                                                                           Ñ
  3.   Ñ   File Name:    State_Storage_Manager.c                                   Ñ
  4.   Ñ   ----------                                                              Ñ
  5.   Ñ                                                                           Ñ
  6.   Ñ   Copyright ⌐ 1990 Apple Computer, Inc.  All Rights Reserved              Ñ
  7.   Ñ                                                                           Ñ
  8.   Ñ       Description                                                         Ñ
  9.   Ñ       -----------                                                         Ñ
  10.   Ñ       This file contains the access routines to the state_storage record  Ñ
  11.   Ñ          of the SLUDGE cdev.  This record contains the current state (values)Ñ
  12.   Ñ          of the SLUDGE cdev.  It is saved as a resource of the cdev file     Ñ
  13.   Ñ          when SLUDGE is not active.                                          Ñ
  14.   Ñ                                                                           Ñ
  15.   Ñ       History                                                             Ñ
  16.   Ñ       -------                                                             Ñ
  17.   Ñ                                                                           Ñ
  18.   Ñ       Author          Date            Description                         Ñ
  19.   Ñ       ------------------------------------------------------------------  Ñ
  20.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  21.   Ñ                                                                           Ñ
  22.   Ñ                                                                           Ñ
  23.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  24.  
  25. #include "State_Storage_Manager.h"
  26. #include <Dialogs.h>
  27. #include <Resources.h>
  28. #include <Memory.h>
  29. #include <Errors.h>
  30. #include <Devices.h>
  31. #include <Packages.h>
  32.  
  33.  
  34.  
  35.  
  36. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  37.   Ñ                                                                           Ñ
  38.   Ñ   Function Name:   Set_State_Storage_Recommended_CDEV_Return_Value        Ñ
  39.   Ñ   --------------                                                          Ñ
  40.   Ñ                                                                           Ñ
  41.   Ñ       Description                                                         Ñ
  42.   Ñ       -----------                                                         Ñ
  43.   Ñ            This function sets the resource error condition true.              Ñ
  44.   Ñ                                                                           Ñ
  45.   Ñ                                                                           Ñ
  46.   Ñ       History                                                             Ñ
  47.   Ñ       -------                                                             Ñ
  48.   Ñ                                                                           Ñ
  49.   Ñ       Author          Date            Description                         Ñ
  50.   Ñ       ------------------------------------------------------------------  Ñ
  51.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  52.   Ñ                                                                           Ñ
  53.   Ñ                                                                           Ñ
  54.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  55. void    Set_State_Storage_Recommended_CDEV_Return_Value(Handle cdevStorage, long value)
  56. {
  57.     HLock(cdevStorage);
  58.     ((State_Storage_Pointer) *cdevStorage)->State_Storage_Recommended_CDEV_Return_Value = value;
  59.     HUnlock(cdevStorage);
  60.     
  61. }
  62.  
  63. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  64.   Ñ                                                                           Ñ
  65.   Ñ   Function Name:   Set_Resource_Error_Condition                           Ñ
  66.   Ñ   --------------                                                          Ñ
  67.   Ñ                                                                           Ñ
  68.   Ñ       Description                                                         Ñ
  69.   Ñ       -----------                                                         Ñ
  70.   Ñ            This function sets the resource error condition true.              Ñ
  71.   Ñ                                                                           Ñ
  72.   Ñ                                                                           Ñ
  73.   Ñ       History                                                             Ñ
  74.   Ñ       -------                                                             Ñ
  75.   Ñ                                                                           Ñ
  76.   Ñ       Author          Date            Description                         Ñ
  77.   Ñ       ------------------------------------------------------------------  Ñ
  78.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  79.   Ñ                                                                           Ñ
  80.   Ñ                                                                           Ñ
  81.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  82. void    Set_Resource_Error_Condition(Handle cdevStorage)
  83. {
  84.     HLock(cdevStorage);
  85.     ((State_Storage_Pointer) *cdevStorage)->Allocated_State = false;
  86.     ((State_Storage_Pointer) *cdevStorage)->Resource_Error_State = true;
  87.     HUnlock(cdevStorage);
  88.     
  89. }
  90.  
  91. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  92.   Ñ                                                                           Ñ
  93.   Ñ   Function Name:         Write_State_Resource                             Ñ
  94.   Ñ   --------------                                                          Ñ
  95.   Ñ                                                                           Ñ
  96.   Ñ       Description                                                         Ñ
  97.   Ñ       -----------                                                         Ñ
  98.   Ñ       This command writes the current contents of the state storage to       Ñ
  99.   Ñ          the state storage resource.  This command should be called by every Ñ
  100.   Ñ       routine (except Set_Resource_Error_Condition) that changes the stateÑ
  101.   Ñ          storage data.                                                          Ñ
  102.   Ñ                                                                           Ñ
  103.   Ñ       History                                                             Ñ
  104.   Ñ       -------                                                             Ñ
  105.   Ñ                                                                           Ñ
  106.   Ñ       Author          Date            Description                         Ñ
  107.   Ñ       ------------------------------------------------------------------  Ñ
  108.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  109.   Ñ                                                                           Ñ
  110.   Ñ                                                                           Ñ
  111.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  112. void Write_State_Resource(Handle cdevStorage)
  113. {
  114.     short res_error;
  115.     short junk;
  116.     
  117.     HLock(cdevStorage);
  118.     ChangedResource( cdevStorage);
  119.         
  120.     res_error = ResError();
  121.     
  122.                                          /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  123.                                            Ñ                                        Ñ
  124.                                            Ñ    If the resource can not be changed    Ñ
  125.                                            Ñ    then put up the proper alert, set     Ñ
  126.                                            Ñ    stae manager error condition, and    Ñ
  127.                                            Ñ    recommend a CDEV return value.        Ñ
  128.                                            Ñ                                        Ñ
  129.                                            ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  130.     if (res_error != noErr)
  131.         {
  132.         junk = StopAlert(1,nil);
  133.         Set_Resource_Error_Condition(cdevStorage);
  134.         Set_State_Storage_Recommended_CDEV_Return_Value(cdevStorage,cdevGenErr);
  135.         }
  136.  
  137.     WriteResource(cdevStorage);
  138.     HUnlock(cdevStorage);
  139.  
  140. }
  141. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  142.   Ñ                                                                           Ñ
  143.   Ñ   Function Name:   Set_Allocated_Condition                                Ñ
  144.   Ñ   --------------                                                          Ñ
  145.   Ñ                                                                           Ñ
  146.   Ñ       Description                                                         Ñ
  147.   Ñ       -----------                                                         Ñ
  148.   Ñ            This function sets the allocated condition true.                   Ñ
  149.   Ñ                                                                           Ñ
  150.   Ñ                                                                           Ñ
  151.   Ñ       History                                                             Ñ
  152.   Ñ       -------                                                             Ñ
  153.   Ñ                                                                           Ñ
  154.   Ñ       Author          Date            Description                         Ñ
  155.   Ñ       ------------------------------------------------------------------  Ñ
  156.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  157.   Ñ                                                                           Ñ
  158.   Ñ                                                                           Ñ
  159.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  160. void    Set_Allocated_Condition(Handle cdevStorage)
  161. {
  162.     HLock(cdevStorage);
  163.     ((State_Storage_Pointer) *cdevStorage)->Allocated_State = true;
  164.     ((State_Storage_Pointer) *cdevStorage)->Resource_Error_State = false;
  165.     HUnlock(cdevStorage);
  166.     
  167.     Write_State_Resource(cdevStorage);
  168. }
  169.  
  170.                                          /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  171.                                            Ñ                                        Ñ
  172.                                            Ñ  On/Off button manager state routines    Ñ
  173.                                            Ñ                                        Ñ
  174.                                            ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  175. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  176.   Ñ                                                                           Ñ
  177.   Ñ   Function Name:   Set_On_Off_Error_Condition                             Ñ
  178.   Ñ   --------------                                                          Ñ
  179.   Ñ                                                                           Ñ
  180.   Ñ       Description                                                         Ñ
  181.   Ñ       -----------                                                         Ñ
  182.   Ñ            This function sets the On/Off button error condition to the       Ñ
  183.   Ñ            passed Boolean value.                                              Ñ
  184.   Ñ                                                                           Ñ
  185.   Ñ                                                                           Ñ
  186.   Ñ       History                                                             Ñ
  187.   Ñ       -------                                                             Ñ
  188.   Ñ                                                                           Ñ
  189.   Ñ       Author          Date            Description                         Ñ
  190.   Ñ       ------------------------------------------------------------------  Ñ
  191.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  192.   Ñ                                                                           Ñ
  193.   Ñ                                                                           Ñ
  194.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  195. void    Set_On_Off_Error_Condition(Handle cdevStorage, Boolean value)
  196. {
  197.     HLock(cdevStorage);
  198.     ((State_Storage_Pointer) *cdevStorage)->On_Off_Error_Condition = value;
  199.     HUnlock(cdevStorage);
  200.     
  201.     Write_State_Resource(cdevStorage);
  202. }
  203.  
  204.  
  205. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  206.   Ñ                                                                           Ñ
  207.   Ñ   Function Name:    Get_On_Off_Error_Condition                              Ñ
  208.   Ñ   --------------                                                          Ñ
  209.   Ñ                                                                           Ñ
  210.   Ñ       Description                                                         Ñ
  211.   Ñ       -----------                                                         Ñ
  212.   Ñ       This query returns the On/Off button error condition.                  Ñ
  213.   Ñ                                                                           Ñ
  214.   Ñ       History                                                             Ñ
  215.   Ñ       -------                                                             Ñ
  216.   Ñ                                                                           Ñ
  217.   Ñ       Author          Date            Description                         Ñ
  218.   Ñ       ------------------------------------------------------------------  Ñ
  219.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  220.   Ñ                                                                           Ñ
  221.   Ñ                                                                           Ñ
  222.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  223. Boolean Get_On_Off_Error_Condition(Handle cdevStorage)
  224. {
  225.     Boolean rvalue;
  226.     
  227.     HLock(cdevStorage);
  228.     rvalue = ((State_Storage_Pointer) *cdevStorage)->On_Off_Error_Condition;
  229.     HUnlock(cdevStorage);
  230.  
  231.     return(rvalue);
  232. }
  233.  
  234. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  235.   Ñ                                                                           Ñ
  236.   Ñ   Function Name:    Set_On_Off_Recommended_CDEV_Return_Value              Ñ
  237.   Ñ   --------------                                                          Ñ
  238.   Ñ                                                                           Ñ
  239.   Ñ       Description                                                         Ñ
  240.   Ñ       -----------                                                         Ñ
  241.   Ñ       This command sets the On/Off button's recommended CDEV return value Ñ
  242.   Ñ          to the passed value.                                                  Ñ
  243.   Ñ                                                                           Ñ
  244.   Ñ       History                                                             Ñ
  245.   Ñ       -------                                                             Ñ
  246.   Ñ                                                                           Ñ
  247.   Ñ       Author          Date            Description                         Ñ
  248.   Ñ       ------------------------------------------------------------------  Ñ
  249.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  250.   Ñ                                                                           Ñ
  251.   Ñ                                                                           Ñ
  252.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  253. void  Set_On_Off_Recommended_CDEV_Return_Value(Handle cdevStorage, long value)
  254. {
  255.     HLock(cdevStorage);
  256.     ((State_Storage_Pointer) *cdevStorage)->On_Off_Recommended_CDEV_Return_Value = value;
  257.     HUnlock(cdevStorage);
  258.     
  259.     Write_State_Resource(cdevStorage);
  260. }
  261.  
  262.  
  263. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  264.   Ñ                                                                           Ñ
  265.   Ñ   Function Name:      Get_On_Off_Recommended_CDEV_Return_Value            Ñ
  266.   Ñ   --------------                                                          Ñ
  267.   Ñ                                                                           Ñ
  268.   Ñ       Description                                                         Ñ
  269.   Ñ       -----------                                                         Ñ
  270.   Ñ       This query returns the On/Off button's recommended CDEV return       Ñ
  271.   Ñ          value.                                                              Ñ
  272.   Ñ                                                                           Ñ
  273.   Ñ       History                                                             Ñ
  274.   Ñ       -------                                                             Ñ
  275.   Ñ                                                                           Ñ
  276.   Ñ       Author          Date            Description                         Ñ
  277.   Ñ       ------------------------------------------------------------------  Ñ
  278.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  279.   Ñ                                                                           Ñ
  280.   Ñ                                                                           Ñ
  281.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  282. long Get_On_Off_Recommended_CDEV_Return_Value(Handle cdevStorage)
  283. {
  284.     short rvalue;
  285.     
  286.     HLock(cdevStorage);
  287.     rvalue = ((State_Storage_Pointer) *cdevStorage)->On_Off_Recommended_CDEV_Return_Value;
  288.     HUnlock(cdevStorage);
  289.  
  290.     return(rvalue);
  291. }
  292.  
  293. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  294.   Ñ                                                                           Ñ
  295.   Ñ   Function Name:   SetUp_State_Storage                                     Ñ
  296.   Ñ   --------------                                                          Ñ
  297.   Ñ                                                                           Ñ
  298.   Ñ       Description                                                         Ñ
  299.   Ñ       -----------                                                         Ñ
  300.   Ñ       This command allocates the CDEV storage in the passed Handle.       Ñ
  301.   Ñ                                                                              Ñ
  302.   Ñ          If there is enough memory available for the allocation then         Ñ
  303.   Ñ       Allocated is the resulting state, otherwise the resulting state       Ñ
  304.   Ñ       is Nil Storage.                                                      Ñ
  305.   Ñ                                                                           Ñ
  306.   Ñ                                                                           Ñ
  307.   Ñ       History                                                             Ñ
  308.   Ñ       -------                                                             Ñ
  309.   Ñ                                                                           Ñ
  310.   Ñ       Author          Date            Description                         Ñ
  311.   Ñ       ------------------------------------------------------------------  Ñ
  312.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  313.   Ñ                                                                           Ñ
  314.   Ñ                                                                           Ñ
  315.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  316. void SetUp_State_Storage(Handle *cdevStorage)
  317. {
  318.     
  319.     if (Count1Resources('SRES') != 0)
  320.          *cdevStorage = Get1Resource('SRES', 0);
  321.     else
  322.         {
  323.         *cdevStorage = NewHandle(sizeof(State_Storage_Record));
  324.         if (MemError() != noErr)
  325.             *cdevStorage = nil;
  326.         else
  327.             {
  328.             HLock(*cdevStorage);
  329.             
  330.             ((State_Storage_Pointer) **cdevStorage)->Sludge_Factor = 0;
  331.             
  332.             AddResource(*cdevStorage, 'SRES', 0, "\015State Storage");
  333.             if (ResError() != noErr)
  334.                 DebugStr("\022AddResource failed");
  335.                 
  336.             
  337.             Write_State_Resource(*cdevStorage);
  338.             HUnlock(*cdevStorage);
  339.  
  340.             Set_Allocated_Condition(*cdevStorage);
  341.             
  342.             
  343.             Set_ONFF_Value(*cdevStorage, false);
  344.             
  345.             }
  346.         }
  347. }
  348.  
  349.  
  350. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  351.   Ñ                                                                           Ñ
  352.   Ñ   Function Name:      State_Storage_Allocated                              Ñ
  353.   Ñ   --------------                                                          Ñ
  354.   Ñ                                                                           Ñ
  355.   Ñ       Description                                                         Ñ
  356.   Ñ       -----------                                                         Ñ
  357.   Ñ       This query returns true if the storage in the passed Handle is in   Ñ
  358.   Ñ       the Allocated state or false if it is in the Nil Storage state.     Ñ
  359.   Ñ                                                                           Ñ
  360.   Ñ       History                                                             Ñ
  361.   Ñ       -------                                                             Ñ
  362.   Ñ                                                                           Ñ
  363.   Ñ       Author          Date            Description                         Ñ
  364.   Ñ       ------------------------------------------------------------------  Ñ
  365.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  366.   Ñ                                                                           Ñ
  367.   Ñ                                                                           Ñ
  368.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  369. Boolean State_Storage_Allocated(Handle cdevStorage)
  370. {
  371.     Boolean        rvalue;
  372.     
  373.     HLock(cdevStorage);
  374.     rvalue = ((State_Storage_Pointer) *cdevStorage)->Allocated_State;
  375.     HUnlock(cdevStorage);
  376.     
  377.     return(rvalue);
  378. }
  379.  
  380. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  381.   Ñ                                                                           Ñ
  382.   Ñ   Function Name:      State_Storage_Nil                                   Ñ
  383.   Ñ   --------------                                                          Ñ
  384.   Ñ                                                                           Ñ
  385.   Ñ       Description                                                         Ñ
  386.   Ñ       -----------                                                         Ñ
  387.   Ñ       This query returns true if and only if the storage in the passed       Ñ
  388.   Ñ          Handle is in the Nil storage state.                                  Ñ
  389.   Ñ                                                                           Ñ
  390.   Ñ       History                                                             Ñ
  391.   Ñ       -------                                                             Ñ
  392.   Ñ                                                                           Ñ
  393.   Ñ       Author          Date            Description                         Ñ
  394.   Ñ       ------------------------------------------------------------------  Ñ
  395.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  396.   Ñ                                                                           Ñ
  397.   Ñ                                                                           Ñ
  398.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  399. Boolean State_Storage_Nil(Handle cdevStorage)
  400. {
  401.     return(cdevStorage == nil);
  402. }
  403.  
  404. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  405.   Ñ                                                                           Ñ
  406.   Ñ   Function Name:      State_Storage_Resource_Error                        Ñ
  407.   Ñ   --------------                                                          Ñ
  408.   Ñ                                                                           Ñ
  409.   Ñ       Description                                                         Ñ
  410.   Ñ       -----------                                                         Ñ
  411.   Ñ       This query returns true if and only if the storage in the passed       Ñ
  412.   Ñ          Handle is in the resource error storage state.                      Ñ
  413.   Ñ                                                                           Ñ
  414.   Ñ       History                                                             Ñ
  415.   Ñ       -------                                                             Ñ
  416.   Ñ                                                                           Ñ
  417.   Ñ       Author          Date            Description                         Ñ
  418.   Ñ       ------------------------------------------------------------------  Ñ
  419.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  420.   Ñ                                                                           Ñ
  421.   Ñ                                                                           Ñ
  422.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  423. Boolean State_Storage_Resource_Error(Handle cdevStorage)
  424. {
  425.     Boolean        rvalue;
  426.     
  427.     HLock(cdevStorage);
  428.     rvalue = ((State_Storage_Pointer) *cdevStorage)->Resource_Error_State;
  429.     HUnlock(cdevStorage);
  430.     
  431.     return(rvalue);
  432. }
  433.  
  434.  
  435. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  436.   Ñ                                                                           Ñ
  437.   Ñ   Function Name:      Get_State_Storage_Recommended_CDEV_Return_Value     Ñ
  438.   Ñ   --------------                                                          Ñ
  439.   Ñ                                                                           Ñ
  440.   Ñ       Description                                                         Ñ
  441.   Ñ       -----------                                                         Ñ
  442.   Ñ       This query returns the State Storage manager's recommended CDEV       Ñ
  443.   Ñ          return value.                                                          Ñ
  444.   Ñ                                                                           Ñ
  445.   Ñ       History                                                             Ñ
  446.   Ñ       -------                                                             Ñ
  447.   Ñ                                                                           Ñ
  448.   Ñ       Author          Date            Description                         Ñ
  449.   Ñ       ------------------------------------------------------------------  Ñ
  450.   Ñ       Kevin McEntee   7/25/89         Original Implementation             Ñ
  451.   Ñ                                                                           Ñ
  452.   Ñ                                                                           Ñ
  453.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  454. long Get_State_Storage_Recommended_CDEV_Return_Value(Handle cdevStorage)
  455. {
  456.     long rvalue;
  457.     
  458.     HLock(cdevStorage);
  459.     rvalue = ((State_Storage_Pointer) *cdevStorage)->State_Storage_Recommended_CDEV_Return_Value;
  460.     HUnlock(cdevStorage);
  461.     
  462.     return(rvalue);
  463. }
  464.  
  465.  
  466.  
  467. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  468.   Ñ                                                                           Ñ
  469.   Ñ   Function Name:      Get_ONFF_Value                                      Ñ
  470.   Ñ   --------------                                                          Ñ
  471.   Ñ                                                                           Ñ
  472.   Ñ       Description                                                         Ñ
  473.   Ñ       -----------                                                         Ñ
  474.   Ñ       This query returns the value of the ONFF resource.                  Ñ
  475.   Ñ                                                                           Ñ
  476.   Ñ       History                                                             Ñ
  477.   Ñ       -------                                                             Ñ
  478.   Ñ                                                                           Ñ
  479.   Ñ       Author          Date            Description                         Ñ
  480.   Ñ       ------------------------------------------------------------------  Ñ
  481.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  482.   Ñ                                                                           Ñ
  483.   Ñ                                                                           Ñ
  484.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  485. short Get_ONFF_Value(Handle cdevStorage)
  486. {
  487.     Boolean rvalue;
  488.     
  489.     HLock(cdevStorage);
  490.     rvalue = ((State_Storage_Pointer) *cdevStorage)->ONFF_Value;
  491.     HUnlock(cdevStorage);
  492.  
  493.     return(rvalue);
  494. }
  495.  
  496.  
  497.  
  498. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  499.   Ñ                                                                           Ñ
  500.   Ñ   Function Name:       Set_ONFF_Value                                      Ñ
  501.   Ñ   --------------                                                          Ñ
  502.   Ñ                                                                           Ñ
  503.   Ñ       Description                                                         Ñ
  504.   Ñ       -----------                                                         Ñ
  505.   Ñ       This command sets value of the ONFF resource to the passed value.      Ñ
  506.   Ñ                                                                           Ñ
  507.   Ñ       History                                                             Ñ
  508.   Ñ       -------                                                             Ñ
  509.   Ñ                                                                           Ñ
  510.   Ñ       Author          Date            Description                         Ñ
  511.   Ñ       ------------------------------------------------------------------  Ñ
  512.   Ñ       Kevin McEntee   7/20/89         Original Implementation             Ñ
  513.   Ñ                                                                           Ñ
  514.   Ñ                                                                           Ñ
  515.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  516. void Set_ONFF_Value(Handle cdevStorage, short value)
  517. {
  518.     HLock(cdevStorage);
  519.     ((State_Storage_Pointer) *cdevStorage)->ONFF_Value = value;
  520.     HUnlock(cdevStorage);
  521.     
  522.     Write_State_Resource(cdevStorage);
  523. }    
  524.  
  525.  
  526. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  527.   Ñ                                                                           Ñ
  528.   Ñ   Identifier:     Set_Sludge_Factor                                          Ñ
  529.   Ñ   -----------                                                             Ñ
  530.   Ñ                                                                           Ñ
  531.   Ñ       Description                                                         Ñ
  532.   Ñ       -----------                                                         Ñ
  533.   Ñ       This function sets the SLUDGE factor to the passed value.              Ñ
  534.   Ñ                                                                           Ñ
  535.   Ñ       History                                                             Ñ
  536.   Ñ       -------                                                             Ñ
  537.   Ñ                                                                           Ñ
  538.   Ñ       Author          Date            Description                         Ñ
  539.   Ñ       ------------------------------------------------------------------  Ñ
  540.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  541.   Ñ                                                                           Ñ
  542.   Ñ                                                                           Ñ
  543.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  544. void     Set_Sludge_Factor(Handle cdevStorage, int new_value)
  545. {
  546.     HLock(cdevStorage);
  547.     ((State_Storage_Pointer) *cdevStorage)->Sludge_Factor = new_value;
  548.     HUnlock(cdevStorage);
  549.     
  550.     Write_State_Resource(cdevStorage);
  551. }
  552.  
  553.  
  554.  
  555. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  556.   Ñ                                                                           Ñ
  557.   Ñ   Identifier:     Increment_Sludge_Factor                                  Ñ
  558.   Ñ   -----------                                                             Ñ
  559.   Ñ                                                                           Ñ
  560.   Ñ       Description                                                         Ñ
  561.   Ñ       -----------                                                         Ñ
  562.   Ñ       This function increments the SLUDGE factor.                          Ñ
  563.   Ñ                                                                           Ñ
  564.   Ñ       History                                                             Ñ
  565.   Ñ       -------                                                             Ñ
  566.   Ñ                                                                           Ñ
  567.   Ñ       Author          Date            Description                         Ñ
  568.   Ñ       ------------------------------------------------------------------  Ñ
  569.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  570.   Ñ                                                                           Ñ
  571.   Ñ                                                                           Ñ
  572.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  573. void    Increment_Sludge_Factor(Handle cdevStorage)
  574. {
  575.     HLock(cdevStorage);
  576.     if (((State_Storage_Pointer) *cdevStorage)->Sludge_Factor < 999)
  577.         ((State_Storage_Pointer) *cdevStorage)->Sludge_Factor++;
  578.     HUnlock(cdevStorage);
  579.     
  580.     Write_State_Resource(cdevStorage);
  581. }
  582.  
  583. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  584.   Ñ                                                                           Ñ
  585.   Ñ   Identifier:     Decrement_Sludge_Factor                                  Ñ
  586.   Ñ   -----------                                                             Ñ
  587.   Ñ                                                                           Ñ
  588.   Ñ       Description                                                         Ñ
  589.   Ñ       -----------                                                         Ñ
  590.   Ñ       This function decrements the SLUDGE factor.                          Ñ
  591.   Ñ                                                                           Ñ
  592.   Ñ       History                                                             Ñ
  593.   Ñ       -------                                                             Ñ
  594.   Ñ                                                                           Ñ
  595.   Ñ       Author          Date            Description                         Ñ
  596.   Ñ       ------------------------------------------------------------------  Ñ
  597.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  598.   Ñ                                                                           Ñ
  599.   Ñ                                                                           Ñ
  600.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  601. void    Decrement_Sludge_Factor(Handle cdevStorage)
  602. {
  603.     HLock(cdevStorage);
  604.     if (((State_Storage_Pointer) *cdevStorage)->Sludge_Factor > 0)
  605.         ((State_Storage_Pointer) *cdevStorage)->Sludge_Factor--;
  606.     HUnlock(cdevStorage);
  607.     
  608.     Write_State_Resource(cdevStorage);
  609. }
  610.  
  611. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  612.   Ñ                                                                           Ñ
  613.   Ñ   Identifier:     Get_Sludge_Factor                                          Ñ
  614.   Ñ   -----------                                                             Ñ
  615.   Ñ                                                                           Ñ
  616.   Ñ       Description                                                         Ñ
  617.   Ñ       -----------                                                         Ñ
  618.   Ñ       This function returns the SLUDGE factor.                              Ñ
  619.   Ñ                                                                           Ñ
  620.   Ñ       History                                                             Ñ
  621.   Ñ       -------                                                             Ñ
  622.   Ñ                                                                           Ñ
  623.   Ñ       Author          Date            Description                         Ñ
  624.   Ñ       ------------------------------------------------------------------  Ñ
  625.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  626.   Ñ                                                                           Ñ
  627.   Ñ                                                                           Ñ
  628.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  629. long    Get_Sludge_Factor(Handle cdevStorage)
  630. {
  631.     long rvalue;
  632.     
  633.     HLock(cdevStorage);
  634.     rvalue = ((State_Storage_Pointer) *cdevStorage)->Sludge_Factor;
  635.     HUnlock(cdevStorage);
  636.     
  637.     return(rvalue);
  638.     
  639. }
  640.  
  641.  
  642. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  643.   Ñ                                                                           Ñ
  644.   Ñ   Identifier:          Set_About_Box_State                                 Ñ
  645.   Ñ   -----------                                                             Ñ
  646.   Ñ                                                                           Ñ
  647.   Ñ       Description                                                         Ñ
  648.   Ñ       -----------                                                         Ñ
  649.   Ñ       This function sets the about box state to true.                      Ñ
  650.   Ñ                                                                           Ñ
  651.   Ñ       History                                                             Ñ
  652.   Ñ       -------                                                             Ñ
  653.   Ñ                                                                           Ñ
  654.   Ñ       Author          Date            Description                         Ñ
  655.   Ñ       ------------------------------------------------------------------  Ñ
  656.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  657.   Ñ                                                                           Ñ
  658.   Ñ                                                                           Ñ
  659.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  660. void     Set_About_Box_State(Handle cdevStorage)
  661. {
  662.     HLock(cdevStorage);
  663.     ((State_Storage_Pointer) *cdevStorage)->About_Box_State = true;
  664.     HUnlock(cdevStorage);
  665.     
  666.     Write_State_Resource(cdevStorage);
  667. }
  668.  
  669. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  670.   Ñ                                                                           Ñ
  671.   Ñ   Identifier:          Clear_About_Box_State                               Ñ
  672.   Ñ   -----------                                                             Ñ
  673.   Ñ                                                                           Ñ
  674.   Ñ       Description                                                         Ñ
  675.   Ñ       -----------                                                         Ñ
  676.   Ñ       This function sets the about box state to false.                      Ñ
  677.   Ñ                                                                           Ñ
  678.   Ñ       History                                                             Ñ
  679.   Ñ       -------                                                             Ñ
  680.   Ñ                                                                           Ñ
  681.   Ñ       Author          Date            Description                         Ñ
  682.   Ñ       ------------------------------------------------------------------  Ñ
  683.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  684.   Ñ                                                                           Ñ
  685.   Ñ                                                                           Ñ
  686.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  687. void     Clear_About_Box_State(Handle cdevStorage)
  688. {
  689.     HLock(cdevStorage);
  690.     ((State_Storage_Pointer) *cdevStorage)->About_Box_State = false;
  691.     HUnlock(cdevStorage);
  692.     
  693.     Write_State_Resource(cdevStorage);
  694. }
  695.  
  696. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  697.   Ñ                                                                           Ñ
  698.   Ñ   Identifier:          In_About_Box_State                                  Ñ
  699.   Ñ   -----------                                                             Ñ
  700.   Ñ                                                                           Ñ
  701.   Ñ       Description                                                         Ñ
  702.   Ñ       -----------                                                         Ñ
  703.   Ñ       This returns true if the cdev is in the about box state, false      Ñ
  704.   Ñ          otherwise.                                                          Ñ
  705.   Ñ                                                                           Ñ
  706.   Ñ       History                                                             Ñ
  707.   Ñ       -------                                                             Ñ
  708.   Ñ                                                                           Ñ
  709.   Ñ       Author          Date            Description                         Ñ
  710.   Ñ       ------------------------------------------------------------------  Ñ
  711.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  712.   Ñ                                                                           Ñ
  713.   Ñ                                                                           Ñ
  714.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  715. Boolean In_About_Box_State(Handle cdevStorage)
  716. {
  717.     Boolean rvalue;
  718.     
  719.     HLock(cdevStorage);
  720.     rvalue = ((State_Storage_Pointer) *cdevStorage)->About_Box_State;
  721.     HUnlock(cdevStorage);
  722.     
  723.     return(rvalue);
  724. }
  725.  
  726.  
  727.  
  728. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  729.   Ñ                                                                           Ñ
  730.   Ñ   Identifier:      Set_Original_A_TRAP_Exception_Vector_Value              Ñ
  731.   Ñ   -----------                                                             Ñ
  732.   Ñ                                                                           Ñ
  733.   Ñ       Description                                                         Ñ
  734.   Ñ       -----------                                                         Ñ
  735.   Ñ       This function saves the value for the original a-trap exception     Ñ
  736.   Ñ          vector.                                                              Ñ
  737.   Ñ                                                                           Ñ
  738.   Ñ       History                                                             Ñ
  739.   Ñ       -------                                                             Ñ
  740.   Ñ                                                                           Ñ
  741.   Ñ       Author          Date            Description                         Ñ
  742.   Ñ       ------------------------------------------------------------------  Ñ
  743.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  744.   Ñ                                                                           Ñ
  745.   Ñ                                                                           Ñ
  746.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  747. void     Set_Original_A_TRAP_Exception_Vector_Value(Handle cdevStorage, Ptr value)
  748. {
  749.     HLock(cdevStorage);
  750.     ((State_Storage_Pointer) *cdevStorage)->Original_A_TRAP_Exception_Vector_Value = value;
  751.     HUnlock(cdevStorage);
  752.     
  753.     Write_State_Resource(cdevStorage);
  754. }
  755.  
  756. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  757.   Ñ                                                                           Ñ
  758.   Ñ   Identifier:      Get_Original_A_TRAP_Exception_Vector_Value              Ñ
  759.   Ñ   -----------                                                             Ñ
  760.   Ñ                                                                           Ñ
  761.   Ñ       Description                                                         Ñ
  762.   Ñ       -----------                                                         Ñ
  763.   Ñ       This function returns the value for the saved a-trap exception      Ñ
  764.   Ñ          vector.                                                              Ñ
  765.   Ñ                                                                           Ñ
  766.   Ñ       History                                                             Ñ
  767.   Ñ       -------                                                             Ñ
  768.   Ñ                                                                           Ñ
  769.   Ñ       Author          Date            Description                         Ñ
  770.   Ñ       ------------------------------------------------------------------  Ñ
  771.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  772.   Ñ                                                                           Ñ
  773.   Ñ                                                                           Ñ
  774.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  775. Ptr     Get_Original_A_TRAP_Exception_Vector_Value(Handle cdevStorage)
  776. {
  777.     Ptr rvalue;
  778.     
  779.     HLock(cdevStorage);
  780.     rvalue = ((State_Storage_Pointer) *cdevStorage)->Original_A_TRAP_Exception_Vector_Value;
  781.     HUnlock(cdevStorage);
  782.     
  783.     return(rvalue);
  784. }
  785.  
  786. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  787.   Ñ                                                                           Ñ
  788.   Ñ   Identifier:      Set_Original_JUMP_TRACE_Exception_Vector_Value          Ñ
  789.   Ñ   -----------                                                             Ñ
  790.   Ñ                                                                           Ñ
  791.   Ñ       Description                                                         Ñ
  792.   Ñ       -----------                                                         Ñ
  793.   Ñ       This function saves the value for the original a-jump_trace           Ñ
  794.   Ñ          exception vector.                                                      Ñ
  795.   Ñ                                                                           Ñ
  796.   Ñ       History                                                             Ñ
  797.   Ñ       -------                                                             Ñ
  798.   Ñ                                                                           Ñ
  799.   Ñ       Author          Date            Description                         Ñ
  800.   Ñ       ------------------------------------------------------------------  Ñ
  801.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  802.   Ñ                                                                           Ñ
  803.   Ñ                                                                           Ñ
  804.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  805. void     Set_Original_JUMP_TRACE_Exception_Vector_Value(Handle cdevStorage, Ptr value)
  806. {
  807.     HLock(cdevStorage);
  808.     ((State_Storage_Pointer) *cdevStorage)->Original_JUMP_TRACE_Exception_Vector_Value = value;
  809.     HUnlock(cdevStorage);
  810.     
  811.     Write_State_Resource(cdevStorage);
  812. }
  813.  
  814. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  815.   Ñ                                                                           Ñ
  816.   Ñ   Identifier:      Get_Original_JUMP_TRACE_Exception_Vector_Value          Ñ
  817.   Ñ   -----------                                                             Ñ
  818.   Ñ                                                                           Ñ
  819.   Ñ       Description                                                         Ñ
  820.   Ñ       -----------                                                         Ñ
  821.   Ñ       This function returns the value for the saved jump_trace exception  Ñ
  822.   Ñ          vector.                                                              Ñ
  823.   Ñ                                                                           Ñ
  824.   Ñ       History                                                             Ñ
  825.   Ñ       -------                                                             Ñ
  826.   Ñ                                                                           Ñ
  827.   Ñ       Author          Date            Description                         Ñ
  828.   Ñ       ------------------------------------------------------------------  Ñ
  829.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  830.   Ñ                                                                           Ñ
  831.   Ñ                                                                           Ñ
  832.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  833. Ptr     Get_Original_JUMP_TRACE_Exception_Vector_Value(Handle cdevStorage)
  834. {
  835.     Ptr rvalue;
  836.     
  837.     HLock(cdevStorage);
  838.     rvalue = ((State_Storage_Pointer) *cdevStorage)->Original_JUMP_TRACE_Exception_Vector_Value;
  839.     HUnlock(cdevStorage);
  840.     
  841.     return(rvalue);
  842. }
  843.  
  844. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  845.   Ñ                                                                           Ñ
  846.   Ñ   Identifier:      Set_Location_Of_Parasite_Resource                          Ñ
  847.   Ñ   -----------                                                             Ñ
  848.   Ñ                                                                           Ñ
  849.   Ñ       Description                                                         Ñ
  850.   Ñ       -----------                                                         Ñ
  851.   Ñ       This function saves the location of the parasite resource.          Ñ
  852.   Ñ                                                                           Ñ
  853.   Ñ       History                                                             Ñ
  854.   Ñ       -------                                                             Ñ
  855.   Ñ                                                                           Ñ
  856.   Ñ       Author          Date            Description                         Ñ
  857.   Ñ       ------------------------------------------------------------------  Ñ
  858.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  859.   Ñ                                                                           Ñ
  860.   Ñ                                                                           Ñ
  861.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  862. void     Set_Location_Of_Parasite_Resource(Handle cdevStorage, Handle value)
  863. {
  864.     HLock(cdevStorage);
  865.     ((State_Storage_Pointer) *cdevStorage)->Location_Of_Parasite_Resource = value;
  866.     HUnlock(cdevStorage);
  867.     
  868.     Write_State_Resource(cdevStorage);
  869. }
  870.  
  871. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  872.   Ñ                                                                           Ñ
  873.   Ñ   Identifier:      Get_Location_Of_Parasite_Resource                          Ñ
  874.   Ñ   -----------                                                             Ñ
  875.   Ñ                                                                           Ñ
  876.   Ñ       Description                                                         Ñ
  877.   Ñ       -----------                                                         Ñ
  878.   Ñ       This function returns the value for the saved jump_trace exception  Ñ
  879.   Ñ          vector.                                                              Ñ
  880.   Ñ                                                                           Ñ
  881.   Ñ       History                                                             Ñ
  882.   Ñ       -------                                                             Ñ
  883.   Ñ                                                                           Ñ
  884.   Ñ       Author          Date            Description                         Ñ
  885.   Ñ       ------------------------------------------------------------------  Ñ
  886.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  887.   Ñ                                                                           Ñ
  888.   Ñ                                                                           Ñ
  889.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  890. Handle     Get_Location_Of_Parasite_Resource(Handle cdevStorage)
  891. {
  892.     Handle rvalue;
  893.     
  894.     HLock(cdevStorage);
  895.     rvalue = ((State_Storage_Pointer) *cdevStorage)->Location_Of_Parasite_Resource;
  896.     HUnlock(cdevStorage);
  897.     
  898.     return(rvalue);
  899. }
  900.  
  901.